1. Field of the Invention
Embodiments of the present invention relate generally to graphics systems and more specifically to an SLI approval policy database.
2. Description of the Related Art
A typical computer system includes, without limitation, a central processing unit (CPU), a graphics processing unit (GPU), at least one display device, and one or more input devices, such as a keyboard and a mouse. The computer system may also include a mass storage device, such as a hard disk drive, which typically includes a file system, an operating system, and a set of applications. Advanced computer systems may augment the processing capacity of the first GPU with a second GPU, whereby the two GPUs are configured to coordinate their operations. One technology known in the art for coordinating the operation of two or more GPUs is the scalable link interface (SLI). When two or more GPUs are utilizing SLI technology to coordinate their processing, they are referred to as operating in SLI mode.
While many computer system configurations allow for two or more GPUs to operate in SLI mode, certain situations preclude the use of GPUs in SLI mode. For example, some GPU products are not licensed for use in SLI mode, although the GPU may be technically capable of performing properly in such a configuration. Additionally, certain computer systems and certain GPUs may not be capable of operating properly in SLI mode for technical reasons. To avoid configurations that attempt to violate either licensing arrangements or technical system capabilities, an approval mechanism is commonly compiled into the executable code of a GPU driver. The approval mechanism allows known and authorized multi-GPU configurations to execute in SLI mode, while precluding unknown multi-GPU configurations from executing in SLI mode. The approval mechanism is typically implemented as a compiled sequence of instructions that attempts to match the current computer system configuration to system configurations that are known to be approved SLI configurations. If a match is found, the system is allowed to operate in SLI mode. Otherwise, the system is not allowed to operate in SLI mode. Each time a new permitted configuration (known as an “approval”) is added, additional executable code must be added to the GPU driver, and the GPU driver must be re-built to incorporate the new executable code.
As the number of different approved configurations grows, the amount of compiled code within the GPU driver also grows to accommodate the various approved SLI configurations, increasing the difficulty and inefficiency of managing GPU driver development. Furthermore, evaluating a new SLI configuration for potential approval requires that the GPU driver be repeatedly compiled by different individuals who need to ultimately coordinate their activities in order to properly release the GPU driver for production. Some of the individuals involved in the overall development process are developers, who need to write code for operating and managing a given GPU. However, the individuals responsible for determining which system configurations should be approved to operate in SLI mode are typically not the developers, and, in fact, tend to be much less familiar with the build process and tools for compiling the GPU driver than the developers. The need for numerous individuals to potentially modify and compile the GPU driver introduces inefficiency and opportunities for error in the overall development process.
While certain efficiencies may be gained in carefully managing the current development process, the underlying management complexity and potential for error remains a problem so long as the approval mechanism uses compiled executable code to define specific approvals. Furthermore, the current development process requires a completely new instance of the GPU driver to be built each time a new approval is being examined. Building a new GPU driver can be cumbersome and time consuming and introduces inefficiencies in the approval examination process.
As the foregoing illustrates, what is needed in the art is a mechanism for providing SLI approval within a GPU driver, but without the need to re-build the GPU driver in order to examine and incorporate new, approved SLI configurations.